Personal Computer World 2009 February/PCWFEB09.iso/Software/Resources/Chat & Communication/Digsby build 37/digsby_setup.exe/lib/platform.pyo

Python Compiled Bytecode | 2008-10-13 | 21KB | 846 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

__copyright__ = '\n    Copyright (c) 1999-2000, Marc-Andre Lemburg; mailto:[e-mail]\n    Copyright (c) 2000-2003, eGenix.com Software GmbH; mailto:[e-mail]\n\n    Permission to use, copy, modify, and distribute this software and its\n    documentation for any purpose and without fee or royalty is hereby granted,\n    provided that the above copyright notice appear in all copies and that\n    both that copyright notice and this permission notice appear in\n    supporting documentation or portions thereof, including modifications,\n    that you make.\n\n    EGENIX.COM SOFTWARE GMBH DISCLAIMS ALL WARRANTIES WITH REGARD TO\n    THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\n    FITNESS, IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL,\n    INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING\n    FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,\n    NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION\n    WITH THE USE OR PERFORMANCE OF THIS SOFTWARE !\n\n'
__version__ = '1.0.4'
import sys
import string
import os
import re
_libc_search = re.compile('(__libc_init)|(GLIBC_([0-9.]+))|(libc(_\\w+)?\\.so(?:\\.(\\d[0-9.]*))?)')

def libc_ver(executable = sys.executable, lib = '', version = '', chunksize = 2048):
    f = open(executable, 'rb')
    binary = f.read(chunksize)
    pos = 0
    while None:
        m = _libc_search.search(binary, pos)
        if not m:
            binary = f.read(chunksize)
            if not binary:
                break

            pos = 0
            continue

        (libcinit, glibc, glibcversion, so, threads, soversion) = m.groups()
        if libcinit and not lib:
            lib = 'libc'
        elif glibc:
            if lib != 'glibc':
                lib = 'glibc'
                version = glibcversion
            elif glibcversion > version:
                version = glibcversion

        elif so:
            if lib != 'glibc':
                lib = 'libc'
                if soversion > version:
                    version = soversion

                if threads and version[-len(threads):] != threads:
                    version = version + threads



        pos = m.end()
        continue
        return (lib, version)


def _dist_try_harder(distname, version, id):
    if os.path.exists('/var/adm/inst-log/info'):
        info = open('/var/adm/inst-log/info').readlines()
        distname = 'SuSE'
        for line in info:
            tv = string.split(line)
            if len(tv) == 2:
                (tag, value) = tv

            if tag == 'MIN_DIST_VERSION':
                version = string.strip(value)
                continue
            len(tv) == 2
            if tag == 'DIST_IDENT':
                values = string.split(value, '-')
                id = values[2]
                continue

        return (distname, version, id)

    if os.path.exists('/etc/.installed'):
        info = open('/etc/.installed').readlines()
        for line in info:
            pkg = string.split(line, '-')
            if len(pkg) >= 2 and pkg[0] == 'OpenLinux':
                return ('OpenLinux', pkg[1], id)
                continue


    if os.path.isdir('/usr/lib/setup'):
        verfiles = os.listdir('/usr/lib/setup')
        for n in range(len(verfiles) - 1, -1, -1):
            if verfiles[n][:14] != 'slack-version-':
                del verfiles[n]
                continue

        if verfiles:
            verfiles.sort()
            distname = 'slackware'
            version = verfiles[-1][14:]
            return (distname, version, id)


    return (distname, version, id)

_release_filename = re.compile('(\\w+)[-_](release|version)')
_release_version = re.compile('([\\d.]+)[^(]*(?:\\((.+)\\))?')

def dist(distname = '', version = '', id = '', supported_dists = ('SuSE', 'debian', 'fedora', 'redhat', 'mandrake')):

    try:
        etc = os.listdir('/etc')
    except os.error:
        return (distname, version, id)

    for file in etc:
        m = _release_filename.match(file)
        if m:
            (_distname, dummy) = m.groups()
            if _distname in supported_dists:
                distname = _distname
                break

        _distname in supported_dists
    else:
        return _dist_try_harder(distname, version, id)
    f = open('/etc/' + file, 'r')
    firstline = f.readline()
    f.close()
    m = _release_version.search(firstline)
    if m:
        (_version, _id) = m.groups()
        if _version:
            version = _version

        if _id:
            id = _id

    else:
        l = string.split(string.strip(firstline))
        if l:
            version = l[0]
            if len(l) > 1:
                id = l[1]


    return (distname, version, id)


class _popen:
    tmpfile = ''
    pipe = None
    bufsize = None
    mode = 'r'

    def __init__(self, cmd, mode = 'r', bufsize = None):
        if mode != 'r':
            raise ValueError, 'popen()-emulation only supports read mode'

        import tempfile as tempfile
        self.tmpfile = tmpfile = tempfile.mktemp()
        os.system(cmd + ' > %s' % tmpfile)
        self.pipe = open(tmpfile, 'rb')
        self.bufsize = bufsize
        self.mode = mode


    def read(self):
        return self.pipe.read()


    def readlines(self):
        if self.bufsize is not None:
            return self.pipe.readlines()



    def close(self, remove = os.unlink, error = os.error):
        if self.pipe:
            rc = self.pipe.close()
        else:
            rc = 255
        if self.tmpfile:

            try:
                remove(self.tmpfile)
            except error:
                pass
            except:
                None<EXCEPTION MATCH>error


        None<EXCEPTION MATCH>error
        return rc

    __del__ = close


def popen(cmd, mode = 'r', bufsize = None):
    popen = None
    if os.environ.get('OS', '') == 'Windows_NT':

        try:
            import win32pipe as win32pipe
        except ImportError:
            pass

        popen = win32pipe.popen

    if popen is None:
        if hasattr(os, 'popen'):
            popen = os.popen
            if sys.platform == 'win32':

                try:
                    popen('')
                except os.error:
                    popen = _popen
                except:
                    None<EXCEPTION MATCH>os.error


            None<EXCEPTION MATCH>os.error
        else:
            popen = _popen

    if bufsize is None:
        return popen(cmd, mode)
    else:
        return popen(cmd, mode, bufsize)


def _norm_version(version, build = ''):
    l = string.split(version, '.')
    if build:
        l.append(build)


    try:
        ints = map(int, l)
    except ValueError:
        strings = l

    strings = map(str, ints)
    version = string.join(strings[:3], '.')
    return version

_ver_output = re.compile('(?:([\\w ]+) ([\\w.]+) .*Version ([\\d.]+))')

def _syscmd_ver(system = '', release = '', version = '', supported_platforms = ('win32', 'win16', 'dos', 'os2')):
    if sys.platform not in supported_platforms:
        return (system, release, version)

    for cmd in ('ver', 'command /c ver', 'cmd /c ver'):

        try:
            pipe = popen(cmd)
            info = pipe.read()
            if pipe.close():
                raise os.error, 'command failed'
        except os.error:
            why = None
            continue
            continue
            except IOError:
                why = None
                continue
                continue
            else:
                break
        return (system, release, version)
        info = string.strip(info)
        m = _ver_output.match(info)
        if m:
            (system, release, version) = m.groups()
            if release[-1] == '.':
                release = release[:-1]

            if version[-1] == '.':
                version = version[:-1]

            version = _norm_version(version)


    return (system, release, version)


def _win32_getvalue(key, name, default = ''):
    RegQueryValueEx = RegQueryValueEx
    import win32api

    try:
        return RegQueryValueEx(key, name)
    except:
        return default



def win32_ver(release = '', version = '', csd = '', ptype = ''):

    try:
        import win32api
    except ImportError:
        return (release, version, csd, ptype)

    RegQueryValueEx = RegQueryValueEx
    RegOpenKeyEx = RegOpenKeyEx
    RegCloseKey = RegCloseKey
    GetVersionEx = GetVersionEx
    import win32api
    HKEY_LOCAL_MACHINE = HKEY_LOCAL_MACHINE
    VER_PLATFORM_WIN32_NT = VER_PLATFORM_WIN32_NT
    VER_PLATFORM_WIN32_WINDOWS = VER_PLATFORM_WIN32_WINDOWS
    import win32con
    (maj, min, buildno, plat, csd) = GetVersionEx()
    version = '%i.%i.%i' % (maj, min, buildno & 65535)
    if csd[:13] == 'Service Pack ':
        csd = 'SP' + csd[13:]

    if plat == VER_PLATFORM_WIN32_WINDOWS:
        regkey = 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion'
        if maj == 4:
            if min == 0:
                release = '95'
            elif min == 10:
                release = '98'
            elif min == 90:
                release = 'Me'
            else:
                release = 'postMe'
        elif maj == 5:
            release = '2000'

    elif plat == VER_PLATFORM_WIN32_NT:
        regkey = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion'
        if maj <= 4:
            release = 'NT'
        elif maj == 5:
            if min == 0:
                release = '2000'
            elif min == 1:
                release = 'XP'
            elif min == 2:
                release = '2003Server'
            else:
                release = 'post2003'

    elif not release:
        release = '%i.%i' % (maj, min)

    return (release, version, csd, ptype)

    try:
        keyCurVer = RegOpenKeyEx(HKEY_LOCAL_MACHINE, regkey)
        RegQueryValueEx(keyCurVer, 'SystemRoot')
    except:
        return (release, version, csd, ptype)

    build = _win32_getvalue(keyCurVer, 'CurrentBuildNumber', ('', 1))[0]
    ptype = _win32_getvalue(keyCurVer, 'CurrentType', (ptype, 1))[0]
    version = _norm_version(version, build)
    RegCloseKey(keyCurVer)
    return (release, version, csd, ptype)


def _mac_ver_lookup(selectors, default = None):
    gestalt = gestalt
    import gestalt
    import MacOS as MacOS
    l = []
    append = l.append
    for selector in selectors:

        try:
            append(gestalt(selector))
        continue
        except (RuntimeError, MacOS.Error):
            append(default)
            continue



    return l


def _bcd2str(bcd):
    return hex(bcd)[2:]


def mac_ver(release = '', versioninfo = ('', '', ''), machine = ''):

    try:
        import gestalt
        import MacOS
    except ImportError:
        return (release, versioninfo, machine)

    (sysv, sysu, sysa) = _mac_ver_lookup(('sysv', 'sysu', 'sysa'))
    if sysv:
        major = (sysv & 65280) >> 8
        minor = (sysv & 240) >> 4
        patch = sysv & 15
        if (major, minor) >= (10, 4):
            (major, minor, patch) = _mac_ver_lookup(('sys1', 'sys2', 'sys3'))
            release = '%i.%i.%i' % (major, minor, patch)
        else:
            release = '%s.%i.%i' % (_bcd2str(major), minor, patch)

    if sysu:
        major = int((sysu & 0xFF000000L) >> 24)
        minor = (sysu & 15728640) >> 20
        bugfix = (sysu & 983040) >> 16
        stage = (sysu & 65280) >> 8
        nonrel = sysu & 255
        version = '%s.%i.%i' % (_bcd2str(major), minor, bugfix)
        nonrel = _bcd2str(nonrel)
        stage = {
            32: 'development',
            64: 'alpha',
            96: 'beta',
            128: 'final' }.get(stage, '')
        versioninfo = (version, stage, nonrel)

    if sysa:
        machine = {
            1: '68k',
            2: 'PowerPC',
            10: 'i386' }.get(sysa, '')

    return (release, versioninfo, machine)


def _java_getprop(name, default):
    System = System
    import java.lang

    try:
        return System.getProperty(name)
    except:
        return default



def java_ver(release = '', vendor = '', vminfo = ('', '', ''), osinfo = ('', '', '')):

    try:
        import java.lang as java
    except ImportError:
        return (release, vendor, vminfo, osinfo)

    vendor = _java_getprop('java.vendor', vendor)
    release = _java_getprop('java.version', release)
    (vm_name, vm_release, vm_vendor) = vminfo
    vm_name = _java_getprop('java.vm.name', vm_name)
    vm_vendor = _java_getprop('java.vm.vendor', vm_vendor)
    vm_release = _java_getprop('java.vm.version', vm_release)
    vminfo = (vm_name, vm_release, vm_vendor)
    (os_name, os_version, os_arch) = osinfo
    os_arch = _java_getprop('java.os.arch', os_arch)
    os_name = _java_getprop('java.os.name', os_name)
    os_version = _java_getprop('java.os.version', os_version)
    osinfo = (os_name, os_version, os_arch)
    return (release, vendor, vminfo, osinfo)


def system_alias(system, release, version):
    if system == 'Rhapsody':
        return ('MacOS X Server', system + release, version)
    elif system == 'SunOS':
        if release < '5':
            return (system, release, version)

        l = string.split(release, '.')
        if l:

            try:
                major = int(l[0])
            except ValueError:
                pass

            major = major - 3
            l[0] = str(major)
            release = string.join(l, '.')

        if release < '6':
            system = 'Solaris'
        else:
            system = 'Solaris'
    elif system == 'IRIX64':
        system = 'IRIX'
        if version:
            version = version + ' (64bit)'
        else:
            version = '64bit'
    elif system in ('win32', 'win16'):
        system = 'Windows'

    return (system, release, version)


def _platform(*args):
    platform = string.join(map(string.strip, filter(len, args)), '-')
    replace = string.replace
    platform = replace(platform, ' ', '_')
    platform = replace(platform, '/', '-')
    platform = replace(platform, '\\', '-')
    platform = replace(platform, ':', '-')
    platform = replace(platform, ';', '-')
    platform = replace(platform, '"', '-')
    platform = replace(platform, '(', '-')
    platform = replace(platform, ')', '-')
    platform = replace(platform, 'unknown', '')
    while None:
        cleaned = replace(platform, '--', '-')
        if cleaned == platform:
            break

        platform = cleaned
        continue
        while platform[-1] == '-':
            platform = platform[:-1]
        return platform


def _node(default = ''):

    try:
        import socket as socket
    except ImportError:
        return default


    try:
        return socket.gethostname()
    except socket.error:
        return default


if not hasattr(os.path, 'abspath'):

    def _abspath(path, isabs = os.path.isabs, join = os.path.join, getcwd = os.getcwd, normpath = os.path.normpath):
        if not isabs(path):
            path = join(getcwd(), path)

        return normpath(path)

else:
    _abspath = os.path.abspath

def _follow_symlinks(filepath):
    filepath = _abspath(filepath)
    while os.path.islink(filepath):
        filepath = os.path.normpath(os.path.join(os.path.dirname(filepath), os.readlink(filepath)))
    return filepath


def _syscmd_uname(option, default = ''):
    if sys.platform in ('dos', 'win32', 'win16', 'os2'):
        return default


    try:
        f = os.popen('uname %s 2> /dev/null' % option)
    except (AttributeError, os.error):
        return default

    output = string.strip(f.read())
    rc = f.close()
    if not output or rc:
        return default
    else:
        return output


def _syscmd_file(target, default = ''):
    target = _follow_symlinks(target)

    try:
        f = os.popen('file %s 2> /dev/null' % target)
    except (AttributeError, os.error):
        return default

    output = string.strip(f.read())
    rc = f.close()
    if not output or rc:
        return default
    else:
        return output

_default_architecture = {
    'win32': ('', 'WindowsPE'),
    'win16': ('', 'Windows'),
    'dos': ('', 'MSDOS') }
_architecture_split = re.compile('[\\s,]').split

def architecture(executable = sys.executable, bits = '', linkage = ''):
    if not bits:
        import struct as struct

        try:
            size = struct.calcsize('P')
        except struct.error:
            size = struct.calcsize('l')

        bits = str(size * 8) + 'bit'

    output = _syscmd_file(executable, '')
    if not output and executable == sys.executable:
        if _default_architecture.has_key(sys.platform):
            (b, l) = _default_architecture[sys.platform]
            if b:
                bits = b

            if l:
                linkage = l


        return (bits, linkage)

    fileout = _architecture_split(output)[1:]
    if 'executable' not in fileout:
        return (bits, linkage)

    if '32-bit' in fileout:
        bits = '32bit'
    elif 'N32' in fileout:
        bits = 'n32bit'
    elif '64-bit' in fileout:
        bits = '64bit'

    if 'ELF' in fileout:
        linkage = 'ELF'
    elif 'PE' in fileout:
        if 'Windows' in fileout:
            linkage = 'WindowsPE'
        else:
            linkage = 'PE'
    elif 'COFF' in fileout:
        linkage = 'COFF'
    elif 'MS-DOS' in fileout:
        linkage = 'MSDOS'

    return (bits, linkage)

_uname_cache = None

def uname():
    global _uname_cache
    if _uname_cache is not None:
        return _uname_cache


    try:
        (system, node, release, version, machine) = os.uname()
    except AttributeError:
        system = sys.platform
        release = ''
        version = ''
        node = _node()
        machine = ''
        processor = ''
        use_syscmd_ver = 1
        if system == 'win32':
            (release, version, csd, ptype) = win32_ver()
            if release and version:
                use_syscmd_ver = 0


        if use_syscmd_ver:
            (system, release, version) = _syscmd_ver(system)
            if system == 'Microsoft Windows':
                system = 'Windows'


        if system in ('win32', 'win16'):
            if not version:
                if system == 'win32':
                    version = '32bit'
                else:
                    version = '16bit'

            system = 'Windows'
        elif system[:4] == 'java':
            (release, vendor, vminfo, osinfo) = java_ver()
            system = 'Java'
            version = string.join(vminfo, ', ')
            if not version:
                version = vendor

        elif os.name == 'mac':
            (version, stage, nonrel) = (release,)
            machine = mac_ver()
            system = 'MacOS'

    except:
        system in ('win32', 'win16')

    if system == 'OpenVMS':
        if not release or release == '0':
            release = version
            version = ''


        try:
            import vms_lib as vms_lib
        except ImportError:
            pass

        (csid, cpu_number) = vms_lib.getsyi('SYI$_CPU', 0)
        if cpu_number >= 128:
            processor = 'Alpha'
        else:
            processor = 'VAX'
    else:
        processor = _syscmd_uname('-p', '')
    if system == 'unknown':
        system = ''

    if node == 'unknown':
        node = ''

    if release == 'unknown':
        release = ''

    if version == 'unknown':
        version = ''

    if machine == 'unknown':
        machine = ''

    if processor == 'unknown':
        processor = ''

    if system == 'Microsoft' and release == 'Windows':
        system = 'Windows'
        release = 'Vista'

    _uname_cache = (system, node, release, version, machine, processor)
    return _uname_cache


def system():
    return uname()[0]


def node():
    return uname()[1]


def release():
    return uname()[2]


def version():
    return uname()[3]


def machine():
    return uname()[4]


def processor():
    return uname()[5]

_sys_version_parser = re.compile('([\\w.+]+)\\s*\\(#?([^,]+),\\s*([\\w ]+),\\s*([\\w :]+)\\)\\s*\\[([^\\]]+)\\]?')
_sys_version_cache = None

def _sys_version():
    global _sys_version_cache
    if _sys_version_cache is not None:
        return _sys_version_cache

    (version, buildno, builddate, buildtime, compiler) = _sys_version_parser.match(sys.version).groups()
    builddate = builddate + ' ' + buildtime
    l = string.split(version, '.')
    if len(l) == 2:
        l.append('0')
        version = string.join(l, '.')

    _sys_version_cache = (version, buildno, builddate, compiler)
    return _sys_version_cache


def python_version():
    return _sys_version()[0]


def python_version_tuple():
    return string.split(_sys_version()[0], '.')


def python_build():
    return _sys_version()[1:3]


def python_compiler():
    return _sys_version()[3]

_platform_cache = { }

def platform(aliased = 0, terse = 0):
    result = _platform_cache.get((aliased, terse), None)
    if result is not None:
        return result

    (system, node, release, version, machine, processor) = uname()
    if machine == processor:
        processor = ''

    if aliased:
        (system, release, version) = system_alias(system, release, version)

    if system == 'Windows':
        (rel, vers, csd, ptype) = win32_ver(version)
        if terse:
            platform = _platform(system, release)
        else:
            platform = _platform(system, release, version, csd)
    elif system in ('Linux',):
        (distname, distversion, distid) = dist('')
        if distname and not terse:
            platform = _platform(system, release, machine, processor, 'with', distname, distversion, distid)
        else:
            (libcname, libcversion) = libc_ver(sys.executable)
            platform = _platform(system, release, machine, processor, 'with', libcname + libcversion)
    elif system == 'Java':
        (os_name, os_version, os_arch) = (r, v, vminfo)
        if terse:
            platform = _platform(system, release, version)
        else:
            platform = _platform(system, release, version, 'on', os_name, os_version, os_arch)
    elif system == 'MacOS':
        if terse:
            platform = _platform(system, release)
        else:
            platform = _platform(system, release, machine)
    elif terse:
        platform = _platform(system, release)
    else:
        (bits, linkage) = architecture(sys.executable)
        platform = _platform(system, release, machine, processor, bits, linkage)
    _platform_cache[(aliased, terse)] = platform
    return platform

if __name__ == '__main__':
    if not 'terse' in sys.argv:
        pass
    terse = '--terse' in sys.argv
    if 'nonaliased' not in sys.argv:
        pass
    aliased = '--nonaliased' not in sys.argv
    print platform(aliased, terse)
    sys.exit(0)